package com.aliexpress.utils;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;

/**
 * @project Fusion-Common
 * @package com.fusionzoom.common.utils
 * @class MyMd5Utils.java
 * @author jiagui E-mail:<zhujiagui@zkingsoft.com>
 * @date 2015年9月9日 下午5:51:19
 * @description MD5加密工具类
 */
public class MyMd5Utils {

	public static void main(String args[]) throws IOException {
	}

	private static final int BUFFER_SIZE = 1024;

	private static final int S11 = 7;
	private static final int S12 = 12;
	private static final int S13 = 17;
	private static final int S14 = 22;
	private static final int S21 = 5;
	private static final int S22 = 9;
	private static final int S23 = 14;
	private static final int S24 = 20;
	private static final int S31 = 4;
	private static final int S32 = 11;
	private static final int S33 = 16;
	private static final int S34 = 23;
	private static final int S41 = 6;
	private static final int S42 = 10;
	private static final int S43 = 15;
	private static final int S44 = 21;

	private static byte padding[] = { (byte) 0x80, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0,
			(byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0,
			(byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0,
			(byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0,
			(byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0,
			(byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0,
			(byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0 };

	private InputStream in = null;
	private boolean stringp = false;
	private int state[] = null;
	private long count = 0;
	private byte buffer[] = null;
	private byte digest[] = null;

	public String stringify(byte buf[]) {
		StringBuffer sb = new StringBuffer(2 * buf.length);
		for (int i = 0; i < buf.length; i++) {
			int h = (buf[i] & 0xf0) >> 4;
			int l = (buf[i] & 0x0f);
			sb.append(new Character((char) ((h > 9) ? 'a' + h - 10 : '0' + h)));
			sb.append(new Character((char) ((l > 9) ? 'a' + l - 10 : '0' + l)));
		}
		return sb.toString();
	}

	private final int F(int x, int y, int z) {
		return ((x & y) | ((~x) & z));
	}

	private final int G(int x, int y, int z) {
		return ((x & z) | (y & (~z)));
	}

	private final int H(int x, int y, int z) {
		return (x ^ y ^ z);
	}

	private final int I(int x, int y, int z) {
		return (y ^ (x | (~z)));
	}

	private final int rotate_left(int x, int n) {
		return ((x << n) | (x >>> (32 - n)));
	}

	private final int FF(int a, int b, int c, int d, int x, int s, int ac) {
		a += (F(b, c, d) + x + ac);
		a = rotate_left(a, s);
		a += b;
		return a;
	}

	private final int GG(int a, int b, int c, int d, int x, int s, int ac) {
		a += (G(b, c, d) + x + ac);
		a = rotate_left(a, s);
		a += b;
		return a;
	}

	private final int HH(int a, int b, int c, int d, int x, int s, int ac) {
		a += (H(b, c, d) + x + ac);
		a = rotate_left(a, s);
		a += b;
		return a;
	}

	private final int II(int a, int b, int c, int d, int x, int s, int ac) {
		a += (I(b, c, d) + x + ac);
		a = rotate_left(a, s);
		a += b;
		return a;
	}

	private final void decode(int output[], byte input[], int off, int len) {
		int i = 0;
		int j = 0;
		for (; j < len; i++, j += 4) {
			output[i] = (((int) (input[off + j] & 0xff)) | (((int) (input[off + j + 1] & 0xff)) << 8)
					| (((int) (input[off + j + 2] & 0xff)) << 16) | (((int) (input[off + j + 3] & 0xff)) << 24));
		}
	}

	private final void transform(byte block[], int offset) {
		int a = state[0];
		int b = state[1];
		int c = state[2];
		int d = state[3];
		int x[] = new int[16];

		decode(x, block, offset, 64);
		/* Round 1 */
		a = FF(a, b, c, d, x[0], S11, 0xd76aa478); /* 1 */
		d = FF(d, a, b, c, x[1], S12, 0xe8c7b756); /* 2 */
		c = FF(c, d, a, b, x[2], S13, 0x242070db); /* 3 */
		b = FF(b, c, d, a, x[3], S14, 0xc1bdceee); /* 4 */
		a = FF(a, b, c, d, x[4], S11, 0xf57c0faf); /* 5 */
		d = FF(d, a, b, c, x[5], S12, 0x4787c62a); /* 6 */
		c = FF(c, d, a, b, x[6], S13, 0xa8304613); /* 7 */
		b = FF(b, c, d, a, x[7], S14, 0xfd469501); /* 8 */
		a = FF(a, b, c, d, x[8], S11, 0x698098d8); /* 9 */
		d = FF(d, a, b, c, x[9], S12, 0x8b44f7af); /* 10 */
		c = FF(c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
		b = FF(b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
		a = FF(a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
		d = FF(d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
		c = FF(c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
		b = FF(b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
		/* Round 2 */
		a = GG(a, b, c, d, x[1], S21, 0xf61e2562); /* 17 */
		d = GG(d, a, b, c, x[6], S22, 0xc040b340); /* 18 */
		c = GG(c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
		b = GG(b, c, d, a, x[0], S24, 0xe9b6c7aa); /* 20 */
		a = GG(a, b, c, d, x[5], S21, 0xd62f105d); /* 21 */
		d = GG(d, a, b, c, x[10], S22, 0x2441453); /* 22 */
		c = GG(c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
		b = GG(b, c, d, a, x[4], S24, 0xe7d3fbc8); /* 24 */
		a = GG(a, b, c, d, x[9], S21, 0x21e1cde6); /* 25 */
		d = GG(d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
		c = GG(c, d, a, b, x[3], S23, 0xf4d50d87); /* 27 */
		b = GG(b, c, d, a, x[8], S24, 0x455a14ed); /* 28 */
		a = GG(a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
		d = GG(d, a, b, c, x[2], S22, 0xfcefa3f8); /* 30 */
		c = GG(c, d, a, b, x[7], S23, 0x676f02d9); /* 31 */
		b = GG(b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */

		/* Round 3 */
		a = HH(a, b, c, d, x[5], S31, 0xfffa3942); /* 33 */
		d = HH(d, a, b, c, x[8], S32, 0x8771f681); /* 34 */
		c = HH(c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
		b = HH(b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
		a = HH(a, b, c, d, x[1], S31, 0xa4beea44); /* 37 */
		d = HH(d, a, b, c, x[4], S32, 0x4bdecfa9); /* 38 */
		c = HH(c, d, a, b, x[7], S33, 0xf6bb4b60); /* 39 */
		b = HH(b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
		a = HH(a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
		d = HH(d, a, b, c, x[0], S32, 0xeaa127fa); /* 42 */
		c = HH(c, d, a, b, x[3], S33, 0xd4ef3085); /* 43 */
		b = HH(b, c, d, a, x[6], S34, 0x4881d05); /* 44 */
		a = HH(a, b, c, d, x[9], S31, 0xd9d4d039); /* 45 */
		d = HH(d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
		c = HH(c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
		b = HH(b, c, d, a, x[2], S34, 0xc4ac5665); /* 48 */

		/* Round 4 */
		a = II(a, b, c, d, x[0], S41, 0xf4292244); /* 49 */
		d = II(d, a, b, c, x[7], S42, 0x432aff97); /* 50 */
		c = II(c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
		b = II(b, c, d, a, x[5], S44, 0xfc93a039); /* 52 */
		a = II(a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
		d = II(d, a, b, c, x[3], S42, 0x8f0ccc92); /* 54 */
		c = II(c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
		b = II(b, c, d, a, x[1], S44, 0x85845dd1); /* 56 */
		a = II(a, b, c, d, x[8], S41, 0x6fa87e4f); /* 57 */
		d = II(d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
		c = II(c, d, a, b, x[6], S43, 0xa3014314); /* 59 */
		b = II(b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
		a = II(a, b, c, d, x[4], S41, 0xf7537e82); /* 61 */
		d = II(d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
		c = II(c, d, a, b, x[2], S43, 0x2ad7d2bb); /* 63 */
		b = II(b, c, d, a, x[9], S44, 0xeb86d391); /* 64 */

		state[0] += a;
		state[1] += b;
		state[2] += c;
		state[3] += d;
	}

	private final void update(byte input[], int len) {
		int index = ((int) (count >> 3)) & 0x3f;
		count += (len << 3);
		int partLen = 64 - index;
		int i = 0;
		if (len >= partLen) {
			System.arraycopy(input, 0, buffer, index, partLen);
			transform(buffer, 0);
			for (i = partLen; i + 63 < len; i += 64)
				transform(input, i);
			index = 0;
		} else {
			i = 0;
		}
		System.arraycopy(input, i, buffer, index, len - i);
	}

	private byte[] end() {
		byte bits[] = new byte[8];
		for (int i = 0; i < 8; i++)
			bits[i] = (byte) ((count >>> (i * 8)) & 0xff);
		int index = ((int) (count >> 3)) & 0x3f;
		int padlen = (index < 56) ? (56 - index) : (120 - index);
		update(padding, padlen);
		update(bits, 8);
		return encode(state, 16);
	}

	// Encode the content.state array into 16 bytes array
	private byte[] encode(int input[], int len) {
		byte output[] = new byte[len];
		int i = 0;
		int j = 0;
		for (; j < len; i++, j += 4) {
			output[j] = (byte) ((input[i]) & 0xff);
			output[j + 1] = (byte) ((input[i] >> 8) & 0xff);
			output[j + 2] = (byte) ((input[i] >> 16) & 0xff);
			output[j + 3] = (byte) ((input[i] >> 24) & 0xff);
		}
		return output;
	}

	/**
	 * Get the digest for our input stream. This method constructs the input
	 * stream digest, and return it, as a a String, following the MD5 (rfc1321)
	 * algorithm,
	 * 
	 * @return An instance of String, giving the message digest.
	 * @exception IOException
	 *                Thrown if the digestifier was unable to read the input
	 *                stream.
	 */

	public byte[] getDigest() throws IOException {
		byte buffer[] = new byte[BUFFER_SIZE];
		int got = -1;

		if (digest != null)
			return digest;
		while ((got = in.read(buffer)) > 0)
			update(buffer, got);
		this.digest = end();
		return digest;
	}

	/**
	 * Get the digest, for this string digestifier. This method doesn't throw
	 * any IOException, since it knows that the underlying stream ws built from
	 * a String.
	 */

	public byte[] processString() {
		if (!stringp)
			throw new RuntimeException(this.getClass().getName() + "[processString]" + " not a string.");
		try {
			return getDigest();
		} catch (IOException ex) {
		}
		throw new RuntimeException(this.getClass().getName() + "[processString]" + ": implementation error.");
	}

	/**
	 * Get the digest, as a proper string.
	 */

	public String getStringDigest() {
		if (digest == null)
			throw new RuntimeException(this.getClass().getName() + "[getStringDigest]" + ": called before processing.");
		return stringify(digest);
	}

	/**
	 * Construct a digestifier for the given string.
	 * 
	 * @param input
	 *            The string to be digestified.
	 * @param encoding
	 *            the encoding name used (such as UTF8)
	 */

	public MyMd5Utils(String input, String enc) {
		byte bytes[] = null;
		try {
			bytes = input.getBytes(enc);
		} catch (UnsupportedEncodingException e) {
			throw new RuntimeException("no " + enc + " encoding!!!");
		}
		this.stringp = true;
		this.in = new ByteArrayInputStream(bytes);
		this.state = new int[4];
		this.buffer = new byte[64];
		this.count = 0;
		state[0] = 0x67452301;
		state[1] = 0xefcdab89;
		state[2] = 0x98badcfe;
		state[3] = 0x10325476;
	}

	/**
	 * Construct a digestifier for the given string.
	 * 
	 * @param input
	 *            The string to be digestified.
	 */

	public MyMd5Utils(String input) {
		this(input, "UTF8");
	}

	/**
	 * Construct a digestifier for the given input stream.
	 * 
	 * @param in
	 *            The input stream to be digestified.
	 */

	public MyMd5Utils(InputStream in) {
		this.stringp = false;
		this.in = in;
		this.state = new int[4];
		this.buffer = new byte[64];
		this.count = 0;
		state[0] = 0x67452301;
		state[1] = 0xefcdab89;
		state[2] = 0x98badcfe;
		state[3] = 0x10325476;
	}

	public void hmac_Md5(String text, String key) throws IOException {
		// output[33] = ( byte ) '\0' ;
		byte k_ipad[] = new byte[64];
		byte k_opad[] = new byte[64];
		byte key1[];
		int i;
		int text_len = text.getBytes().length;
		int key_len = key.getBytes().length;
		key1 = key.getBytes();

		if (key_len > 64) {
			key1 = new MyMd5Utils(key).getDigest();
			key_len = 16;
		}

		for (i = 0; i < 64; i++)
			k_ipad[i] = (byte) 0;
		for (i = 0; i < 64; i++)
			k_opad[i] = (byte) 0;

		for (i = 0; i < key_len; i++) {
			k_ipad[i] = (byte) key1[i];
			k_opad[i] = (byte) key1[i];
		}

		for (i = 0; i < 64; i++) {
			k_ipad[i] ^= 0x36;
			k_opad[i] ^= 0x5c;
		}

		MyMd5Utils md5 = new MyMd5Utils("");
		md5.update(k_ipad, 64);
		md5.update(text.getBytes(), text_len);
		digest = md5.getDigest();

		MyMd5Utils md51 = new MyMd5Utils("");
		md51.update(k_opad, 64);
		md51.update(digest, 16);
		digest = md51.getDigest();
	}

	public static String encodeByMd5(String s) throws Exception {
		MessageDigest md = MessageDigest.getInstance("Md5");
		md.reset();
		byte cryptbyte[] = md.digest(s.getBytes());
		return byteToString(cryptbyte);
	}

	private static final char hexDigits[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e',
			'f' };

	private static String byteToString(byte cryptbyte[]) {
		int j = cryptbyte.length;
		char ac[] = new char[j * 2];
		int k = 0;

		for (int i = 0; i < j; i++) {
			byte byte0 = cryptbyte[i];
			ac[k++] = hexDigits[byte0 >>> 4 & 0xf];
			ac[k++] = hexDigits[byte0 & 0xf];
		}
		return new String(ac);
	}

	public static String binToAscii(byte[] bySourceByte) {
		int len, i;
		byte tb;
		char high, tmp, low;
		String result = new String();
		len = bySourceByte.length;
		for (i = 0; i < len; i++) {
			tb = bySourceByte[i];

			tmp = (char) ((tb >>> 4) & 0x000f);
			if (tmp >= 10)
				high = (char) ('a' + tmp - 10);
			else
				high = (char) ('0' + tmp);
			result += high;
			tmp = (char) (tb & 0x000f);
			if (tmp >= 10)
				low = (char) ('a' + tmp - 10);
			else
				low = (char) ('0' + tmp);

			result += low;
		}
		return result;
	}

	public static String getMd5Value(String md5String, String md5Key) {
		MyMd5Utils md5 = new MyMd5Utils("");
		byte b[] = null;
		try {
			md5.hmac_Md5(md5String, md5Key.trim());
			b = md5.getDigest();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return md5.stringify(b);
	}
}
